package com.dbms.execution.execution;

import com.dbms.common.Column;
import com.dbms.common.Schema;
import com.dbms.common.Tuple;
import com.dbms.common.Type;
import com.dbms.execution.plan.PlanNode;
import com.dbms.storage.BufferPoolManager;
import com.dbms.storage.DiskManager;
import com.dbms.storage.Page;
import com.dbms.storage.TablePage;

import java.io.File;
import java.io.IOException;
import java.time.Duration;
import java.time.Instant;
import java.util.List;
/**
 * FilterExecutor (过滤执行器) 负责处理查询中的 WHERE 子句。
 * 它从其子执行器 (child) 中获取元组，并对每个元组应用一个谓词 (predicate)。
 * 只有当谓词评估为 true 时，该元组才会被传递给上层执行器。
 * 这个版本还包含了用于 EXPLAIN ANALYZE 的计时和计数功能。
 */
public class FilterExecutor implements Executor {
    /**
     * 谓词（Predicate），封装了过滤条件，例如 "id = 2"。
     */
    private final Predicate predicate;
    /**
     * 子执行器，提供待过滤的数据源（例如，一个 SeqScanExecutor）。
     */
    private final Executor child;

    // 【修改】计时器变量改为 long 类型
    private long startTimeNanos;
    private long totalTimeNanos;
    private long rowsProduced;
    /**
     * 构造函数。
     * @param predicate 过滤条件
     * @param child 子执行器
     */
    public FilterExecutor(Predicate predicate, Executor child) {
        this.predicate = predicate;
        this.child = child;
    }

    @Override
    public void open() {
        this.rowsProduced = 0;
        // 【修改】使用 System.nanoTime()
        this.startTimeNanos = System.nanoTime();
        child.open();
    }

    @Override
    public Tuple next() {
        Tuple tuple;
        while ((tuple = child.next()) != null) {
            if (predicate.evaluate(tuple)) {
                this.rowsProduced++;
                return tuple;
            }
        }
        return null;
    }

    @Override
    public void close() {
        child.close();
        // 【修改】计算纳秒耗时
        this.totalTimeNanos = System.nanoTime() - startTimeNanos;
    }

    @Override
    public Schema getSchema() {
        return this.child.getSchema();
    }

    @Override
    public PlanNode getPlanNode() {
        PlanNode node = new PlanNode("Filter", "condition: " + predicate.toString());
        // 【修改】设置纳秒
        node.setExecutionTimeNanos(this.totalTimeNanos);
        node.setRowsProduced(this.rowsProduced);
        node.addChild(child.getPlanNode());
        return node;
    }

//    public static void main(String[] args) throws IOException {
//        String dbFileName = "my_database_with_schema.db";
//
//        // --- 1. 初始化阶段：清理环境、定义Schema ---
//        File dbFile = new File(dbFileName);
//        if (dbFile.exists()) {
//            dbFile.delete();
//        }
//
//        DiskManager diskManager = new DiskManager(dbFileName);
//        BufferPoolManager bufferPoolManager = new BufferPoolManager(10, diskManager);
//
//        // 定义学生表的Schema: (id: INTEGER, name: VARCHAR(20))
//        Schema schema = new Schema(List.of(
//                new Column("id", Type.INTEGER),
//                new Column("name", Type.VARCHAR, 20)
//        ));
//
//        // --- 2. 插入阶段：插入结构化数据 ---
//        System.out.println("--- 正在插入数据 ---");
//        Page page0 = bufferPoolManager.newPage();
//        TablePage tablePage = new TablePage(page0);
//        tablePage.init(); // 初始化页面
//
//        // 创建元组并插入
//        Tuple tuple1 = new Tuple(List.of(1, "Alice"), schema);
//        tablePage.insertTuple(tuple1.getData());
//        System.out.println("插入: " + tuple1);
//
//        Tuple tuple2 = new Tuple(List.of(2, "Bob"), schema);
//        tablePage.insertTuple(tuple2.getData());
//        System.out.println("插入: " + tuple2);
//
//        Tuple tuple3 = new Tuple(List.of(3, "Charlie"), schema);
//        tablePage.insertTuple(tuple3.getData());
//        System.out.println("插入: " + tuple3);
//
//        // 插入完毕，解钉并刷盘
//        bufferPoolManager.unpinPage(page0.getPageId(), true);
//        bufferPoolManager.flushAllPages();
//        System.out.println("--- 数据插入并刷回磁盘完毕 ---\n");
//
//        // --- 3. 查询阶段：构建执行器链并执行 ---
//        System.out.println("--- 开始带条件(id=2)的查询 ---");
//
////        // 构建执行器链：Filter -> SeqScan
////        Executor seqScan = new SeqScanExecutor(bufferPoolManager, diskManager, schema);
//
//        // 创建谓词：筛选 id = 2 的记录。id是第0个字段。
//        Predicate predicate = new Predicate(0, 2);
//
//        Executor filter = new FilterExecutor(predicate, seqScan);
//
//        // 执行查询并打印结果
//        filter.open();
//        Tuple resultTuple;
//        while ((resultTuple = filter.next()) != null) {
//            System.out.println("查询结果: " + resultTuple);
//            // 我们可以验证结果
//            Integer id = (Integer) resultTuple.getValue(0);
//            String name = (String) resultTuple.getValue(1);
//            System.out.println("  -> Parsed: id=" + id + ", name=" + name);
//        }
//        filter.close();
//        System.out.println("--- 查询结束 ---");
//    }


}